{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tips：从 C++ 转向 Rust 的思维切换\n",
    "\n",
    "- **把所有权理解成“谁在负责跑析构”**：move 就是换负责人。\n",
    "- **把借用看成“借走钥匙”**：不可变钥匙可以复制，可变钥匙只有一把。\n",
    "- **生命周期就是“钥匙有效期”**：Rust 用 `'a` 显式记录；C++ 靠人脑。\n",
    "- **遇到新术语，先找 C++ 类比**：理解语义比记名字重要。\n",
    "- **接受“安全为先”理念**：Rust 让编译器拒绝模棱两可的写法，提高长期可靠性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 核心语义与类型系统\n",
    "\n",
    "| Rust 术语                         | C++ 对应                               | 说明                                                         |\n",
    "| --------------------------------- | -------------------------------------- | ------------------------------------------------------------ |\n",
    "| 所有权（Ownership）               | （无直接术语；可类比 RAII/unique_ptr） | Rust 的核心语义：每个值有唯一所有者，离开作用域时自动 drop。 |\n",
    "| 借用（Borrowing）                 | 引用（Reference）、指针（Pointer）     | Rust 用 `&T`/`&mut T` 表示借用，编译器追踪生存期；C++ 引用缺少生命周期检查。 |\n",
    "| 生命周期（Lifetime）              | RAII 生存期 / 作用域                   | Rust 显式追踪引用的有效范围，用 `'a` 表示；C++ 仅靠作用域和开发者自觉。 |\n",
    "| `mut`                             | `const` 反面 / 可变引用                | Rust 中 `let mut x` 允许改变绑定；`&mut T` 表示独占可变借用。 |\n",
    "| 不可变绑定                        | `const`（变量）                        | 默认 `let x = ...` 不可变；C++ 需 `const auto`。             |\n",
    "| 模式匹配（Pattern Matching）      | `switch` + 结构化绑定                  | Rust `match` 支持析构、守卫、穷尽检查；C++20 结构化绑定仅拆解。 |\n",
    "| 枚举（`enum`）                    | 联合体 + 标志 / `std::variant`         | Rust 枚举是代数数据类型，可带数据；C++17 `std::variant` 类似但无穷尽匹配。 |\n",
    "| 元组（Tuple）                     | `std::tuple` / `std::pair`             | Rust 原生语法 `(T1, T2)`；C++ 需 `std::tuple<T1,T2>`。       |\n",
    "| 切片（Slice, `&[T]`, `&mut [T]`） | 指针+长度 (`T*`+`size`) / `std::span`  | Rust 原生支持安全切片；C++20 才有 `std::span`。              |\n",
    "| Trait                             | 抽象基类 / Interface / Concepts        | Rust trait 可要求方法+关联类型；可以 `impl Trait` 给具体类型实现。 |\n",
    "| 泛型（`<T>`）                     | 模板（template）                       | Rust 单态化（monomorphization）类似 C++ 模板；但有 trait bound 检查。 |\n",
    "| 关联类型（Associated Type）       | 嵌套类型 / `using`                     | `trait Iterator { type Item; }`；C++ 可用 `using` 或嵌套类型别名模拟。 |\n",
    "| HRTB（高阶生命周期界限）          | 模板的模板参数 + `auto`                | `for<'a> Fn(&'a T) -> U`；C++20 Concepts 有类似表达力但语法差异大。 |\n",
    "| GAT（Generic Associated Type）    | 模板化嵌套类型                         | Rust 1.65 稳定；C++ 可以用模板模版参数模拟。                 |\n",
    "| `impl Trait`（位置返回）          | `auto` 返回类型（C++14+）/ 概念        | Rust `fn foo() -> impl Iterator<Item=T>`；C++20 `auto foo()->Iterator`。 |\n",
    "| `!`（Never type）                 | `[[noreturn]]` / `std::terminate`      | 表示“永不返回”；用于 `panic!`、无限循环。                    |\n",
    "| `dyn Trait`                       | 运行时多态基类指针                     | 类似 `std::unique_ptr<Base>` 或引用；Rust 需胖指针（指向对象 + vtable）。 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 内存管理与指针\n",
    "\n",
    "| Rust 术语                           | C++ 对应                               | 说明                                                         |\n",
    "| ----------------------------------- | -------------------------------------- | ------------------------------------------------------------ |\n",
    "| `Box<T>`                            | `std::unique_ptr<T>`                   | 堆分配并拥有所有权；`Drop` 时释放。                          |\n",
    "| `Rc<T>`                             | `std::shared_ptr<T>`                   | 非线程安全引用计数；C++ 需注意循环引用，同理需 `Weak<T>`。   |\n",
    "| `Arc<T>`                            | `std::shared_ptr<T>` + 线程安全        | 原子引用计数，线程安全；C++ shared_ptr 默认线程安全但语义略不同。 |\n",
    "| `Weak<T>`                           | `std::weak_ptr<T>`                     | 非拥有弱引用；Rust 区分 `Weak<T>` for `Rc`/`Arc`。           |\n",
    "| 裸指针（`*const T`, `*mut T`）      | 原生指针 `T*`                          | 无借用检查，仅能在 `unsafe` 中解引用。                       |\n",
    "| `RefCell<T>`                        | `std::shared_ptr<T>`+手动 `const_cast` | 提供运行时可变性检查；违反规则时 panic。                     |\n",
    "| `Cell<T>`                           | `std::atomic<T>`/ `mutable`            | 允许在不可变引用下内部修改，但仅存储 `Copy` 类型。           |\n",
    "| `Pin<T>`                            | `std::unique_ptr`+对象置位             | 防止对象被移动；类似于禁止移动的 C++ 类型/`std::move` 限制。 |\n",
    "| `Drop` trait                        | 析构函数                               | 控制资源释放；`drop(obj)` 类似显式调用析构（但只允许一次）。 |\n",
    "| 零成本抽象（Zero-cost abstraction） | 同名理念                               | Rust/Modern C++ 共同追求，Rust 强调由编译器确保。            |\n",
    "| `mem::replace` / `mem::take`        | `std::swap` / `std::exchange`          | 移动出字段后填默认值等。                                     |\n",
    "| `ManuallyDrop<T>`                   | `std::launder` + placement new         | 控制析构时机；避免自动 drop。                                |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 错误处理与异常\n",
    "\n",
    "| Rust                   | C++                                   | 说明                                                         |\n",
    "| ---------------------- | ------------------------------------- | ------------------------------------------------------------ |\n",
    "| `Result<T,E>`          | `std::expected<T,E>`（C++23）/ 状态码 | Rust 主流错误处理，强制显式处理；C++23 才有 expected。       |\n",
    "| `Option<T>`            | `std::optional<T>`                    | 类似 nullable 值。                                           |\n",
    "| `?` 运算符             | `if (!res) return res;` / `try`       | `Result`/`Option` 的传播语法。                               |\n",
    "| `panic!`               | `throw` / `std::terminate`            | 默认展开/中止；C++ 异常是通用机制。Rust 不鼓励常规逻辑用 panic。 |\n",
    "| `anyhow` / `thiserror` | 自定义异常层级                        | 类似基于 `std::exception` 的错误框架。                       |\n",
    "| `catch_unwind`         | `try { } catch (...)`                 | 捕获 `panic`，仅在 `unwind` 策略下可用。                     |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. 模块、工程与构建\n",
    "\n",
    "| Rust                            | C++                           | 说明                                                  |\n",
    "| ------------------------------- | ----------------------------- | ----------------------------------------------------- |\n",
    "| Crate                           | 静态库/共享库/可执行          | `Cargo.toml` 中一个 package 可含多个 crate。          |\n",
    "| Cargo                           | CMake / Meson / 手写 Makefile | 官方包管理 + 构建系统。                               |\n",
    "| `cargo check`                   | 静态分析构建                  | 只做类型检查，快于完整编译。                          |\n",
    "| `cargo fmt`                     | `clang-format`                | 官方格式化工具（rustfmt）。                           |\n",
    "| `cargo clippy`                  | `clang-tidy`                  | Lint 工具。                                           |\n",
    "| Module（`mod`）                 | 命名空间 + 文件组织           | Rust module = 文件/文件夹；C++20 modules 引入新语法。 |\n",
    "| crate root (`lib.rs`/`main.rs`) | `main.cpp` / 顶层 TU          | 模块树的根。                                          |\n",
    "| Path (`crate::foo::bar`)        | `namespace::foo::bar`         | 模块路径。                                            |\n",
    "| Feature flag (`cfg(feature)`)   | 宏开关 / 构建选项             | Cargo 特性，类似 `#ifdef`但集成在包管理中。           |\n",
    "| Edition                         | 语言标准版（C++11/14/17…）    | Rust 提供 2015/2018/2021/2024 等 edition，语义兼容。  |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 函数、闭包与控制流\n",
    "\n",
    "| Rust                   | C++                                               | 说明                                                    |\n",
    "| ---------------------- | ------------------------------------------------- | ------------------------------------------------------- |\n",
    "| 闭包 (`                | x                                                 | x+1`)                                                   |\n",
    "| `Fn`/`FnMut`/`FnOnce`  | `const` lambda / mutable lambda / `std::function` | Rust 根据捕获方式自动推断 trait；C++ 通过捕获列表控制。 |\n",
    "| `move` 闭包            | 值捕获 lambda                                     | Rust `move                                              |\n",
    "| `async fn`             | `co_await`/`std::future`（C++20）                 | Rust `async` 返回 `Future`，需要 runtime（Tokio 等）。  |\n",
    "| `await`                | `co_await`                                        | Rust `Future` 轮询驱动；C++ `std::coroutine`.           |\n",
    "| `loop {}`              | `for(;;)`                                         | Rust 无限循环 `loop`；`break` 可带值。                  |\n",
    "| `break 'label expr`    | `goto`/标签多层 break                             | Rust 支持循环标签 + 返回值。                            |\n",
    "| `if let` / `while let` | `if (auto x = ...) { }` + `optional`              | 结构化模式匹配。                                        |\n",
    "| `match`                | `std::visit` + `switch`                           | 穷尽匹配，支持守卫和绑定。                              |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. 泛型、Trait 约束与类型推断\n",
    "\n",
    "| Rust                     | C++                                            | 说明                                                       |\n",
    "| ------------------------ | ---------------------------------------------- | ---------------------------------------------------------- |\n",
    "| `where` 子句             | `requires` 子句 / SFINAE                       | Trait bound 可放在 `where`；C++20 Concepts `requires`.     |\n",
    "| `T: Trait`               | `std::enable_if`/Concept                       | 约束泛型类型实现 trait。                                   |\n",
    "| `T: 'static`             | 无直接对应                                     | 表示 `T` 内不含非 `'static` 借用，通常意味着“拥有数据”。   |\n",
    "| `for<'a> T: Trait<'a>`   | HRTB                                           | 类似 `template <typename T> concept ...`。                 |\n",
    "| `Sized` trait            | `sizeof(T)` 有限                               | 默认类型 `Sized`；可用 `?Sized` 接受 DST（动态大小类型）。 |\n",
    "| 零尺寸类型（ZST）        | 空 struct / `std::monostate`                   | 占用 0 字节；Rust 中常用在标记、PhantomData。              |\n",
    "| `PhantomData<T>`         | `std::type_identity<T>` / `std::phantom`（无） | 绑定泛型参数但不存储数据。                                 |\n",
    "| Eager type inference     | C++ auto                                       | Rust 默认推断，必要时需注解。                              |\n",
    "| Turbofish (`foo::<T>()`) | `template` 显式指明                            | 强制指定泛型类型，与 C++ `foo<T>()` 类似。                 |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. 宏、元编程与代码生成\n",
    "\n",
    "| Rust                       | C++                    | 说明                                                         |\n",
    "| -------------------------- | ---------------------- | ------------------------------------------------------------ |\n",
    "| 声明式宏（`macro_rules!`） | 宏（`#define`）        | Rust 宏 hygienic，匹配语法树；C++ 宏文本替换。               |\n",
    "| 过程宏（Proc Macro）       | 模板元编程 / AST 重写  | 类似代码生成器；可实现 derive、属性宏。                      |\n",
    "| `#[derive(Trait)]`         | `= default` / 模板继承 | 自动生成 trait 实现。                                        |\n",
    "| `#[cfg(...)]`              | `#if/#ifdef`           | 条件编译。                                                   |\n",
    "| 内联汇编 `asm!`            | `asm` / `__asm__`      | 需 `unsafe`。                                                |\n",
    "| const 泛型                 | 模板非类型参数         | Rust `struct Array<T, const N: usize>`；C++ `template<typename T, size_t N>`. |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. 并发与同步\n",
    "\n",
    "| Rust                | C++                                               | 说明                                                         |\n",
    "| ------------------- | ------------------------------------------------- | ------------------------------------------------------------ |\n",
    "| `Send` trait        | 线程可移动                                        | 自动推断；不实现表示不能跨线程传递。                         |\n",
    "| `Sync` trait        | 线程可共享                                        | `&T` 可在线程间共用；类似 C++ `std::mutex`/数据结构是否线程安全。 |\n",
    "| `std::thread`       | `std::thread`（同名）                             | Rust `spawn` 返回 `JoinHandle`。                             |\n",
    "| `Mutex<T>`          | `std::mutex` + `std::lock_guard`                  | Rust guard 实现 `Deref`，自动解锁。                          |\n",
    "| `RwLock<T>`         | `std::shared_mutex`                               | 读写锁。                                                     |\n",
    "| `std::sync::mpsc`   | `std::queue` + 手动同步 / C++20 `std::atomic`     | Rust 自带 channel；C++20 无标准 channel。                    |\n",
    "| `std::sync::atomic` | `std::atomic`                                     | 都是原子操作。                                               |\n",
    "| `Arc<Mutex<T>>`     | `std::shared_ptr<std::mutex>` + `std::lock_guard` | 常见共享可变数据组合。                                       |\n",
    "| `tokio::spawn`      | 自定义线程池任务                                  | Rust async runtime 的协程；C++20 `std::async` 接近。         |\n",
    "| `async/await`       | `co_await`/`std::future`                          | Rust `Future` 需要驱动；C++ 原生协程语义。                   |\n",
    "| 无数据竞争保证      | `std::atomic`/`std::mutex`                        | Rust 类型系统保证安全并发；C++ 靠约定和工具。                |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. 安全与 `unsafe`\n",
    "\n",
    "| Rust                     | C++                          | 说明                                             |\n",
    "| ------------------------ | ---------------------------- | ------------------------------------------------ |\n",
    "| `unsafe` 块              | C++ 默认语义                 | Rust 默认安全，`unsafe` 表示手动承担安全责任。   |\n",
    "| `unsafe fn`              | 不安全函数                   | 调用者需在 `unsafe` 块中调用。                   |\n",
    "| `unsafe trait`           | 标记实现不安全               | 例如 `Send`/`Sync` 的 `unsafe impl`。            |\n",
    "| UB（Undefined Behavior） | 同名                         | Rust 的 UB 仅在 `unsafe` 中；安全代码保证无 UB。 |\n",
    "| `#[repr(C)]`             | `#pragma pack` / POD         | 指定布局与 C ABI 兼容。                          |\n",
    "| FFI (`extern \"C\"`)       | `extern \"C\"`                 | 调用 C 函数/被 C 调用。                          |\n",
    "| `NonNull<T>`             | `T*` 非空                    | 类似 `std::nonnull`（尚无标准）；保证指针非空。  |\n",
    "| `MaybeUninit<T>`         | placement new / 未初始化内存 | 控制初始化流程，避免 UB。                        |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. 诊断、调试与工具链\n",
    "\n",
    "| Rust                         | C++                              | 说明                                    |\n",
    "| ---------------------------- | -------------------------------- | --------------------------------------- |\n",
    "| `rustc`                      | `clang` / `g++`                  | 编译器。                                |\n",
    "| MIR（中间表示）              | LLVM IR 前的 CFG                 | Rust 中间语言，借用检查在此进行。       |\n",
    "| borrow checker               | 静态分析（ASAN/UBSan）           | Rust 编译器原生检查借用规则。           |\n",
    "| `clippy` lint                | `clang-tidy`                     | 提示潜在问题。                          |\n",
    "| `rust-analyzer`              | `clangd`                         | 语言服务器。                            |\n",
    "| `cargo bench`                | Google Benchmark / `std::chrono` | 基准测试。                              |\n",
    "| `cargo miri`                 | UBSan/TSan                       | 解释执行，捕捉 UB。                     |\n",
    "| `panic` 栈展开               | 异常栈展开                       | 类似 C++ 异常，但可配置 `panic=abort`。 |\n",
    "| `perf`, `flamegraph`（Unix） | `perf`, `vtune`                  | 调优工具通用。                          |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 11. 编程范式与常见模式\n",
    "\n",
    "| Rust                       | C++                                    | 说明                                                       |\n",
    "| -------------------------- | -------------------------------------- | ---------------------------------------------------------- |\n",
    "| `iter().map().collect()`   | `std::ranges::views::transform` + `to` | Rust 迭代器链表符合 FP 风格；C++20 ranges 类似。           |\n",
    "| `Iterator` trait           | `std::ranges::input_range` 等概念      | 方法 `next()` 返回 `Option<Item>`。                        |\n",
    "| `IntoIterator`             | `begin()/end()`                        | For 循环使用 `into_iter` / `iter`。                        |\n",
    "| `From`/`Into`              | `explicit/implicit constructor`        | 类型转换 trait。                                           |\n",
    "| `Display`/`Debug`          | `operator<<`（stream）                 | `format!`/`println!` 使用。                                |\n",
    "| `Default`                  | `T{}` / `= default`                    | 提供默认值。                                               |\n",
    "| Builder 模式               | 结构体更新语法                         | Rust `Foo { field, ..defaults }`；C++ 初始化列表/Builder。 |\n",
    "| `Drop guard`               | RAII                                   | Rust `Drop` + 自动释放 = C++ RAII。                        |\n",
    "| `phantom type`             | 标签类型                               | 利用 `PhantomData`，类似 C++ 模板标签。                    |\n",
    "| `#[derive(Copy, Clone)]`   | `= default` 拷贝构造                   | Rust Copy 表示位拷贝。                                     |\n",
    "| `#[derive(PartialEq, Eq)]` | `operator==`                           | 自动实现比较。                                             |\n",
    "| `serde`                    | `nlohmann::json` 等序列化框架          | 序列化/反序列化工具。                                      |\n",
    "| ECS 框架（Bevy, specs）    | 自定义 ECS                             | Rust 常见游戏/并行架构。                                   |\n",
    "| `no_std`                   | 裸机编程                               | 类似 C++ 无标准库环境。                                    |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 12. 常见“反直觉”对应\n",
    "\n",
    "| Rust 行为                 | C++ 习惯                  | 差异点                                            |\n",
    "| ------------------------- | ------------------------- | ------------------------------------------------- |\n",
    "| move 是默认               | 需 `std::move`            | Rust 所有权转移自动发生；C++ 需显式。             |\n",
    "| 不允许可变+不可变同时借用 | 可以                      | Rust 防止数据竞争；C++ 需靠规则。                 |\n",
    "| `async` 函数不是立即执行  | `std::async` 可能启动线程 | Rust `async fn` 返回 Future，需 `await`/runtime。 |\n",
    "| `String` 不可索引         | `std::string` 支持 `s[0]` | Rust UTF-8 安全，需 `.chars()`。                  |\n",
    "| 匹配穷尽检查              | `switch` 可遗漏           | Rust 强制处理所有分支。                           |\n",
    "| 没有隐式类型转换          | 多种隐式转换              | Rust 强制 `as` 或 trait；C++ 有大量隐式构造。     |\n",
    "| `Vec<T>` 扩容时移动元素   | `std::vector<T>` 同样     | 但 Rust move 后旧引用失效；C++ 仍可悬空。         |\n",
    "| 错误返回 `Result`         | 异常/状态码               | Rust 推崇显式错误处理。                           |\n",
    "| `unsafe` 局部化           | 全局默认 unsafe           | Rust 通过 `unsafe` 块聚焦潜在问题。               |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 13. 术语索引（Rust → C++ 快速查找）\n",
    "\n",
    "| Rust 术语        | C++ 类比                               |\n",
    "| ---------------- | -------------------------------------- |\n",
    "| borrow checker   | （无直接；类似 Clang 静态分析 + 规则） |\n",
    "| lifetime         | 作用域 / RAII 生存期                   |\n",
    "| `'static`        | 静态存储期 / 全局                      |\n",
    "| mutable borrow   | 非 const 引用                          |\n",
    "| shared borrow    | const 引用                             |\n",
    "| trait object     | 虚基类指针                             |\n",
    "| enum variant     | `std::variant` 的 alternative          |\n",
    "| crate            | library / TU                           |\n",
    "| cargo            | 包管理 + 构建                          |\n",
    "| panic            | 异常/abort                             |\n",
    "| `Result`         | `std::expected` / 状态码               |\n",
    "| `Option`         | `std::optional`                        |\n",
    "| `Vec<T>`         | `std::vector<T>`                       |\n",
    "| `HashMap<K,V>`   | `std::unordered_map<K,V>`              |\n",
    "| `BTreeMap<K,V>`  | `std::map<K,V>`                        |\n",
    "| `UnsafeCell<T>`  | `mutable` + 手动同步                   |\n",
    "| `Arc<T>`         | `std::shared_ptr<T>`                   |\n",
    "| `Rc<T>`          | 单线程 `std::shared_ptr<T>`            |\n",
    "| `Box<[T]>`       | 动态数组（`std::unique_ptr<T[]>`）     |\n",
    "| `Cow<'a, T>`     | copy-on-write 智能指针（无标准）       |\n",
    "| `Iterator::next` | `++it`/`*it`                           |\n",
    "| `IntoIterator`   | `begin/end` 协议                       |\n",
    "| `Pin`            | 禁止移动的对象                         |\n",
    "| `NonZeroUsize`   | 非零类型（C++ 需自定义）               |\n",
    "| `PhantomData<T>` | 类型标签                               |\n",
    "| `no_std`         | freestanding C++                       |\n",
    "| `std`（Rust）    | `std`（C++，不同库）                   |\n",
    "| `alloc` crate    | allocator 接口                         |\n",
    "| `core` crate     | 无堆基础库                             |\n",
    "| `serde`          | `boost::serialization`/nlohmann::json  |\n",
    "| `tokio`          | ASIO/Boost/futures                     |\n",
    "| `actix`          | actor 框架                             |\n",
    "| `wasm_bindgen`   | Emscripten + WebAssembly               |\n",
    "| `embedded-hal`   | HAL 抽象                               |\n",
    "| `Futures`        | C++ `std::future`/coroutine            |\n",
    "| 所有权 + Drop                                         | RAII                        |\n",
    "| 借用（不可变/可变）、所有权转移                       | 左值/右值引用 (`T&`, `T&&`) |\n",
    "| `Box<T>`                                              | `std::unique_ptr`           |\n",
    "| `Rc<T>`/`Arc<T>`                                      | `std::shared_ptr`           |\n",
    "| `Weak<T>`                                             | `std::weak_ptr`             |\n",
    "| `Option<T>`                                           | `std::optional`             |\n",
    "| `Result<T,E>`                                         | `std::expected`             |\n",
    "| `enum`                                                | `std::variant`              |\n",
    "| `(T1, T2, …)`                                         | `std::tuple`                |\n",
    "| `[T; N]`                                              | `std::array`                |\n",
    "| `&[T]` / `&mut [T]`                                   | `std::span`                 |\n",
    "| `Vec<T>`                                              | `std::vector`               |\n",
    "| `BTreeMap`                                            | `std::map`                  |\n",
    "| `HashMap`                                             | `std::unordered_map`        |\n",
    "| `String`                                              | `std::string`               |\n",
    "| `&str`                                                | `std::string_view`          |\n",
    "| 默认不可变/`&T`                                       | `const`                     |\n",
    "| `Cell<T>`/`RefCell<T>`                                | `mutable`                   |\n",
    "| `const fn`（部分）                                    | `constexpr`                 |\n",
    "| `if` with const generics / `cfg`                      | `constexpr if`              |\n",
    "| 没有直接需要（Rust 内联由编译器决定；可 `#[inline]`） | `inline`                    |\n",
    "| `dyn Trait`                                           | `virtual`                   |\n",
    "| 自动（trait impl）                                    | `override`                  |\n",
    "| `sealed`（无原生）/隐式                               | `final`                     |\n",
    "| `static`（需要 `unsafe`）                             | `static` 变量               |\n",
    "| `thread_local!` 宏                                    | `thread_local`              |\n",
    "| `<T>` 泛型                                            | `template`                  |\n",
    "| trait bounds / `where`                                | SFINAE / Concepts           |\n",
    "| trait bounds + `PhantomData`                          | `std::enable_if`            |\n",
    "| `type` 别名                                           | `typedef` / `using`         |\n",
    "| `MaybeUninit`                                         | placement new               |\n",
    "| trait (`Add`, `Index`, `Deref`)                       | `operator overloading`      |\n",
    "| `println!`/`format!`                                  | `std::cout`/`operator<<`    |\n",
    "| `std::fs`                                             | `std::filesystem`           |\n",
    "| `std::thread`（Rust）                                 | `std::thread`               |\n",
    "| `Mutex`                                               | `std::mutex`                |\n",
    "| `MutexGuard`                                          | `std::lock_guard`           |\n",
    "| `RwLockReadGuard`                                     | `std::shared_lock`          |\n",
    "| `MutexGuard`                                          | `std::unique_lock`          |\n",
    "| `Atomic*`                                             | `std::atomic`               |\n",
    "| `Future`/`async`                                      | `std::future` / 协程        |\n",
    "| `async` + runtime (`tokio::spawn`)                    | `std::async`                |\n",
    "| `anyhow::Error`/`thiserror`                           | `std::exception`            |\n",
    "| `use` / crate 引入                                    | `#include`                  |\n",
    "| `mod`                                                 | `namespace`                 |\n",
    "| `::`（同符号）                                        | `::`（作用域）              |\n",
    "| `const`/`macro_rules!`                                | `#define`                   |\n",
    "| 无需（模块系统）                                      | `#pragma once`              |\n",
    "| `#[cfg]`                                              | `#ifdef`                    |\n",
    "| `std::time`                                           | `std::chrono`               |\n",
    "| `typenum`（第三方）                                   | `std::ratio`                |\n",
    "| 闭包                                                  | `std::bind`                 |\n",
    "| 类型推断                                              | `auto`                      |\n",
    "| `type_of`（无直接；通常不需要）                       | `decltype`                  |\n",
    "| `pub(crate)` / 可见性控制                             | `friend`                    |\n",
    "| `Drop` trait                                          | `virtual destructor`        |\n",
    "| `ManuallyDrop` + `MaybeUninit`                        | `std::launder`              |\n",
    "| 默认 move / `mem::take`                               | `std::move`                 |\n",
    "| 不需要（Rust move 语义简单）                          | `std::forward`              |\n",
    "| `None` / `Option`                                     | `nullptr`                   |\n",
    "| `Box::new` / 自动 drop                                | `new/delete`                |\n",
    "| `alloc::alloc`（unsafe）                              | `malloc/free`               |\n",
    "| `panic` / `std::process`                              | `SIGABRT` 等信号            |\n",
    "| `libloading` crate                                    | `dlopen`/`dlsym`            |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15. 额外资源推荐\n",
    "\n",
    "- **官方**：\n",
    "  - [Rust Book](https://doc.rust-lang.org/book/)\n",
    "  - [Rust Reference](https://doc.rust-lang.org/reference/)\n",
    "  - [Edition Guide](https://doc.rust-lang.org/edition-guide/)\n",
    "- **C++ ↔ Rust 对照阅读**：\n",
    "  - “Rust 想让 C++ 程序员知道的事” 类文章（社区博客/论坛）\n",
    "  - Rust 官方 FAQ 中的权衡解释\n",
    "- **工具辅助**：\n",
    "  - 用 `rust-analyzer` 获取类型/生命周期提示\n",
    "  - `cargo clippy -W clippy::pedantic` 相当于“超严格模式”，帮助理解语义\n",
    "  - `cargo miri` / `sanitizers` 对比调试行为"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "name": "C++17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
